#ifndef OMG_DDS_PRIV_DDS_POST_HPP_
#define OMG_DDS_PRIV_DDS_POST_HPP_

/* Copyright (c) 2009-2010, Real-Time Innovations, Inc.
 * Copyright (c) 2010, Object Management Group, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - Neither the names of the above copyright holders nor the names of their
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL A COPYRIGHT HOLDER OR CONTRIBUTOR BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/* Implementation-specific header for OMG DDS.
 * The contents of this header are non-normative.
 */


namespace priv_dds {
    namespace core {
        class ImplUnsupportedError : public dds::core::UnsupportedError
        {
        public:
            explicit ImplUnsupportedError(const std::string& msg);
            
        public:
            virtual ~ImplUnsupportedError() throw ();
        };
    }
}


// --- Condition: ------------------------------------------------------------

template <typename DELEGATE>
tdds::core::Condition<DELEGATE>::Condition()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::Condition<DELEGATE>::Condition(const Condition& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::Condition<DELEGATE>::~Condition()
{
    // implementation-defined
}


template <typename DELEGATE>
bool tdds::core::Condition<DELEGATE>::get_trigger_value()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::Condition<DELEGATE>&
tdds::core::Condition<DELEGATE>::operator=(
    const tdds::core::Condition<DELEGATE>& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::Condition<DELEGATE>&
tdds::core::Condition<DELEGATE>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- DataReader: -----------------------------------------------------------

template <typename DELEGATE>
tdds::sub::DataReaderBase<DELEGATE>::DataReaderBase(
        const DataReaderBase& src) :
    impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::sub::DataReaderBase<DELEGATE>::~DataReaderBase()
{
    // implementation-defined
}


template <typename T>
dds::sub::DataReader<T>::~DataReader()
{
    // implementation-defined
}


template <typename DELEGATE>
void tdds::sub::DataReaderBase<DELEGATE>::close()
{
    // implementation-defined
}


template <typename T>
dds::sub::ReadCondition<T>
dds::sub::DataReader<T>::create_readcondition(
    const dds::core::SampleState&   sample_states, 
    const dds::core::ViewState&     view_states,
    const dds::core::InstanceState& instance_states)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::core::StatusCondition< dds::sub::DataReader<T> >
dds::sub::DataReader<T>::get_statuscondition()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
typename dds::sub::DataReader<T>::LoanedSamplesType
dds::sub::DataReader<T>::take(int                             max_samples,
                              const dds::core::SampleState&   sample_states, 
                              const dds::core::ViewState&     view_states, 
                              const dds::core::InstanceState& instance_states)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::sub::DataReaderBase<DELEGATE>&
tdds::sub::DataReaderBase<DELEGATE>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::sub::DataReader<T>&
dds::sub::DataReader<T>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- DataReaderQos: --------------------------------------------------------

template<typename DELEGATE>
tdds::sub::DataReaderQos<DELEGATE>::~DataReaderQos()
{
    // implementation-defined
}


template<typename DELEGATE>
const dds::core::policy::Ownership&
tdds::sub::DataReaderQos<DELEGATE>::ownership() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
dds::core::policy::Ownership&
tdds::sub::DataReaderQos<DELEGATE>::ownership()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


namespace tdds {
    namespace sub {
        template <> template <>
        tdds::sub::DataReaderQos<OMG_DDS_DATA_READER_QOS_DELEGATE>&
        tdds::sub::DataReaderQos<OMG_DDS_DATA_READER_QOS_DELEGATE>::operator <<(
            const dds::core::policy::Ownership& policy);
    }
}


template<typename DELEGATE>
const dds::core::policy::Reliability&
tdds::sub::DataReaderQos<DELEGATE>::reliability() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
dds::core::policy::Reliability&
tdds::sub::DataReaderQos<DELEGATE>::reliability()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


namespace tdds {
    namespace sub {
        template <> template <>
        tdds::sub::DataReaderQos<OMG_DDS_DATA_READER_QOS_DELEGATE>&
        tdds::sub::DataReaderQos<OMG_DDS_DATA_READER_QOS_DELEGATE>::operator <<(
            const dds::core::policy::Reliability& policy);
    }
}


template <typename DELEGATE>
dds::core::EntityQos::ConstQosPolicyMapType&
tdds::sub::DataReaderQos<DELEGATE>::policies() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
dds::core::EntityQos::QosPolicyMapType
tdds::sub::DataReaderQos<DELEGATE>::policies()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- DataWriter: -----------------------------------------------------------

template <typename DELEGATE>
tdds::pub::DataWriterBase<DELEGATE>::DataWriterBase(const DataWriterBase& src) :
    impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::pub::DataWriterBase<DELEGATE>::~DataWriterBase()
{
    // implementation-defined
}


template <typename T>
dds::pub::DataWriter<T>::~DataWriter()
{
    // implementation-defined
}


template <typename DELEGATE>
void tdds::pub::DataWriterBase<DELEGATE>::close()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
dds::pub::Publisher
tdds::pub::DataWriterBase<DELEGATE>::get_parent() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::pub::DataWriterBase<DELEGATE>&
tdds::pub::DataWriterBase<DELEGATE>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::pub::DataWriter<T>&
dds::pub::DataWriter<T>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
const dds::core::InstanceHandle
dds::pub::DataWriter<T>::register_instance(
    const T& instance_data)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
void dds::pub::DataWriter<T>::write(const T& instance_data)
{
    // implementation-defined
}


template <typename T>
void dds::pub::DataWriter<T>::write(const T& instance_data,
                                    const dds::core::InstanceHandle& handle)
{
    // implementation-defined
}


// --- DataWriterListener: ---------------------------------------------------

template <typename T>
dds::pub::DataWriterListener<T>::DataWriterListener()
{
    // implementation-defined
}


template <typename T>
dds::pub::DataWriterListener<T>::~DataWriterListener()
{
    // implementation-defined
}


// --- DataWriterQos: --------------------------------------------------------

template<typename DELEGATE>
tdds::pub::DataWriterQos<DELEGATE>::~DataWriterQos()
{
    // implementation-defined
}


template<typename DELEGATE>
const dds::core::policy::Ownership&
tdds::pub::DataWriterQos<DELEGATE>::ownership() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
dds::core::policy::Ownership&
tdds::pub::DataWriterQos<DELEGATE>::ownership()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


namespace tdds {
    namespace pub {
        template <> template <>
        tdds::pub::DataWriterQos<OMG_DDS_DATA_WRITER_QOS_DELEGATE>&
        tdds::pub::DataWriterQos<OMG_DDS_DATA_WRITER_QOS_DELEGATE>::operator <<(
            const dds::core::policy::Ownership& policy);
    }
}


template<typename DELEGATE>
const dds::core::policy::Reliability&
tdds::pub::DataWriterQos<DELEGATE>::reliability() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
dds::core::policy::Reliability&
tdds::pub::DataWriterQos<DELEGATE>::reliability()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


namespace tdds {
    namespace pub {
        template <> template <>
        tdds::pub::DataWriterQos<OMG_DDS_DATA_WRITER_QOS_DELEGATE>&
        tdds::pub::DataWriterQos<OMG_DDS_DATA_WRITER_QOS_DELEGATE>::operator <<(
            const dds::core::policy::Reliability& policy);
    }
}


template <typename DELEGATE>
dds::core::EntityQos::ConstQosPolicyMapType&
tdds::pub::DataWriterQos<DELEGATE>::policies() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
dds::core::EntityQos::QosPolicyMapType
tdds::pub::DataWriterQos<DELEGATE>::policies()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- DomainParticipant: ----------------------------------------------------

template<typename DELEGATE>
tdds::domain::DomainParticipant<DELEGATE>::DomainParticipant()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
tdds::domain::DomainParticipant<DELEGATE>::~DomainParticipant()
{
    // implementation-defined
}


template<typename DELEGATE>
void tdds::domain::DomainParticipant<DELEGATE>::close()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
dds::pub::Publisher
tdds::domain::DomainParticipant<DELEGATE>::create_publisher()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
dds::sub::Subscriber
tdds::domain::DomainParticipant<DELEGATE>::create_subscriber()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
const dds::sub::SubscriberQos
tdds::domain::DomainParticipant<DELEGATE>::get_default_subscriber_qos() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
dds::sub::Subscriber
tdds::domain::DomainParticipant<DELEGATE>::create_subscriber(
    const dds::sub::SubscriberQos& qos,
    const dds::sub::SubscriberListener *a_listener,
    const dds::core::StatusMask& a_mask)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE> template <typename T>
dds::topic::Topic<T>
tdds::domain::DomainParticipant<DELEGATE>::create_topic(
    const std::string& topic_name,
    dds::type::TypeSupport<T> type)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::domain::DomainParticipant<DELEGATE>&
tdds::domain::DomainParticipant<DELEGATE>::operator=(
    const DomainParticipant& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::domain::DomainParticipant<DELEGATE>&
tdds::domain::DomainParticipant<DELEGATE>::operator=(
    const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- DomainParticipantFactory: ---------------------------------------------

template<typename DELEGATE>
tdds::domain::DomainParticipantFactory<DELEGATE>::~DomainParticipantFactory()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
tdds::domain::DomainParticipantFactory<DELEGATE>
tdds::domain::DomainParticipantFactory<DELEGATE>::get_instance()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
dds::domain::DomainParticipant
tdds::domain::DomainParticipantFactory<DELEGATE>::create_participant(
    dds::domain::DomainId domain_id)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
dds::domain::DomainParticipant
tdds::domain::DomainParticipantFactory<DELEGATE>::create_participant(
    dds::domain::DomainId domain_id,
    const dds::domain::DomainParticipantQos& qos,
    const dds::domain::DomainParticipantListener* a_listener,
    const dds::core::StatusMask& mask)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::domain::DomainParticipantFactory<DELEGATE>&
tdds::domain::DomainParticipantFactory<DELEGATE>::operator=(
    const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- Duration: -------------------------------------------------------------

template <typename DELEGATE>
tdds::core::Duration<DELEGATE>::Duration(
        int32_t the_sec,
        uint32_t the_nanosec) :
    impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::Duration<DELEGATE>::~Duration()
{
    // implementation-defined
}


template <typename DELEGATE>
const tdds::core::Duration<DELEGATE>
tdds::core::Duration<DELEGATE>::infinite()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- Entity: ---------------------------------------------------------------

template <typename DELEGATE>
tdds::core::Entity<DELEGATE>::Entity()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::Entity<DELEGATE>::Entity(const Entity& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::Entity<DELEGATE>::~Entity()
{
    // implementation-defined
}


template <typename DELEGATE>
void tdds::core::Entity<DELEGATE>::close()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
void tdds::core::Entity<DELEGATE>::enable()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
const dds::core::InstanceHandle
tdds::core::Entity<DELEGATE>::get_instancehandle()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
const dds::core::StatusMask
tdds::core::Entity<DELEGATE>::get_status_changes()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::Entity<DELEGATE>&
tdds::core::Entity<DELEGATE>::operator=(const Entity& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::Entity<DELEGATE>&
tdds::core::Entity<DELEGATE>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
void tdds::core::Entity<DELEGATE>::retain()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
void tdds::core::Entity<DELEGATE>::set_qos(
    const std::string& qos_library_name,
    const std::string& qos_profile_name)
{
    // implementation-defined
}


// --- InstanceHandle: -------------------------------------------------------

template <typename DELEGATE>
tdds::core::InstanceHandle<DELEGATE>::~InstanceHandle()
{
    // implementation-defined
}


template <typename DELEGATE>
tdds::core::InstanceHandle<DELEGATE>&
tdds::core::InstanceHandle<DELEGATE>::operator=(
    const dds::core::null_type& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
bool
tdds::core::InstanceHandle<DELEGATE>::operator==(
    const dds::core::null_type& other) const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- LoanedSamples: --------------------------------------------------------

template <typename T, typename DELEGATE>
dds::sub::LoanedSamples<T, DELEGATE>::~LoanedSamples()
{
    // implementation-defined
}


template <typename T, typename DELEGATE>
const typename dds::sub::LoanedSamples<T, DELEGATE>::Iterator
dds::sub::LoanedSamples<T, DELEGATE>::begin() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
const typename dds::sub::LoanedSamples<T, DELEGATE>::Iterator
dds::sub::LoanedSamples<T, DELEGATE>::end() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
void dds::sub::LoanedSamples<T, DELEGATE>::return_loan()
{
    // implementation-defined
}


// --- LoanedSamples::Iterator: ----------------------------------------------

template <typename T, typename DELEGATE>
dds::sub::LoanedSamples<T, DELEGATE>::Iterator::Iterator(const Iterator& src) :
    impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
dds::sub::LoanedSamples<T, DELEGATE>::Iterator::~Iterator()
{
    // implementation-defined
}


template <typename T, typename DELEGATE>
typename dds::sub::LoanedSamples<T, DELEGATE>::Iterator&
dds::sub::LoanedSamples<T, DELEGATE>::Iterator::operator=(const Iterator& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
bool
dds::sub::LoanedSamples<T, DELEGATE>::Iterator::operator==(
    const Iterator& other) const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
bool
dds::sub::LoanedSamples<T, DELEGATE>::Iterator::operator!=(
    const Iterator& other) const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
typename dds::sub::LoanedSamples<T, DELEGATE>::Iterator&
dds::sub::LoanedSamples<T, DELEGATE>::Iterator::operator++()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
typename dds::sub::LoanedSamples<T, DELEGATE>::Iterator
dds::sub::LoanedSamples<T, DELEGATE>::Iterator::operator++(int)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
const dds::sub::Sample<T>&
dds::sub::LoanedSamples<T, DELEGATE>::Iterator::operator*()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
const dds::sub::Sample<T>*
dds::sub::LoanedSamples<T, DELEGATE>::Iterator::operator->()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- Ownership: ------------------------------------------------------------

template<typename DELEGATE>
tdds::core::policy::Ownership<DELEGATE>::Ownership(Ownership::Kind) : impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
tdds::core::policy::Ownership<DELEGATE>::~Ownership()
{
    // implementation-defined
}


template<typename DELEGATE>
typename tdds::core::policy::Ownership<DELEGATE>::Kind&
tdds::core::policy::Ownership<DELEGATE>::kind()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- Publisher: ------------------------------------------------------------

template<typename DELEGATE>
tdds::pub::Publisher<DELEGATE>::~Publisher()
{
    // implementation-defined
}


template<typename DELEGATE>
void tdds::pub::Publisher<DELEGATE>::close()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE> template <typename T>
dds::pub::DataWriter<T>
tdds::pub::Publisher<DELEGATE>::create_datawriter(
    const dds::topic::Topic<T>& a_topic)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE> template <typename T>
dds::pub::DataWriter<T>
tdds::pub::Publisher<DELEGATE>::create_datawriter(
    const dds::topic::Topic<T>& a_topic,
    const dds::pub::DataWriterQos& qos,
    dds::pub::DataWriterListener<T>* listener,
    const dds::core::StatusMask& a_mask)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}

template<typename DELEGATE> template <typename T>
dds::pub::DataWriter<T>
tdds::pub::Publisher<DELEGATE>::lookup_datawriter(
    const std::string& topic_name) const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE> template <typename T>
dds::pub::DataWriter<T>
tdds::pub::Publisher<DELEGATE>::lookup_datawriter(
    const dds::topic::Topic<T>& topic) const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
const dds::pub::DataWriterQos
tdds::pub::Publisher<DELEGATE>::get_default_datawriter_qos() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::pub::Publisher<DELEGATE>&
tdds::pub::Publisher<DELEGATE>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- ReadCondition: --------------------------------------------------------

template <typename T>
dds::sub::ReadCondition<T>::~ReadCondition()
{
    // implementation-defined
}


template <typename DELEGATE>
tdds::sub::ReadConditionBase<DELEGATE>::~ReadConditionBase()
{
    // implementation-defined
}


template <typename DELEGATE>
void tdds::sub::ReadConditionBase<DELEGATE>::close()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
bool tdds::sub::ReadConditionBase<DELEGATE>::get_trigger_value()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::sub::ReadCondition<T>&
dds::sub::ReadCondition<T>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::sub::ReadConditionBase<DELEGATE>&
tdds::sub::ReadConditionBase<DELEGATE>::operator=(
    const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- Reference: ------------------------------------------------------------

template <typename DELEGATE>
dds::core::Reference<DELEGATE>::Reference() : ref_impl_()
{
    // implementation-defined
}


template <typename DELEGATE>
dds::core::Reference<DELEGATE>::~Reference()
{
    // implementation-defined
}


template <typename DELEGATE>
bool
dds::core::Reference<DELEGATE>::operator==(const Reference& other)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
bool
dds::core::Reference<DELEGATE>::operator!=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
dds::core::Reference<DELEGATE>&
dds::core::Reference<DELEGATE>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<class TO, class FROM>
TO dds::core::dynamic_ref_cast(const FROM& r)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- Reliability: ----------------------------------------------------------

template <typename DELEGATE>
tdds::core::policy::Reliability<DELEGATE>::Reliability(
        Reliability::Kind the_kind,
        const dds::core::Duration& the_max_blocking_time) :
    impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::policy::Reliability<DELEGATE>::~Reliability()
{
    // implementation-defined
}


template <typename DELEGATE>
typename tdds::core::policy::Reliability<DELEGATE>::Kind&
tdds::core::policy::Reliability<DELEGATE>::kind()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- Sample: ---------------------------------------------------------------

template <typename T, typename DELEGATE>
dds::sub::Sample<T, DELEGATE>::Sample(const Sample& src) : impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
dds::sub::Sample<T, DELEGATE>::~Sample()
{
    // implementation-defined
}


template <typename T, typename DELEGATE>
const T& dds::sub::Sample<T, DELEGATE>::data() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
bool dds::sub::Sample<T, DELEGATE>::is_valid_data() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- StatusCondition: ------------------------------------------------------

template <typename DELEGATE>
tdds::core::StatusConditionBase<DELEGATE>::StatusConditionBase(
        const StatusConditionBase& src) :
    impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::StatusConditionBase<DELEGATE>::~StatusConditionBase()
{
    // implementation-defined
}


template <typename ENTITY>
dds::core::StatusCondition<ENTITY>::~StatusCondition()
{
    // implementation-defined
}


template <typename DELEGATE>
bool tdds::core::StatusConditionBase<DELEGATE>::get_trigger_value()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::StatusConditionBase<DELEGATE>&
tdds::core::StatusConditionBase<DELEGATE>::operator=(
    const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename ENTITY>
dds::core::StatusCondition<ENTITY>&
dds::core::StatusCondition<ENTITY>::operator=(
    const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- Subscriber: -----------------------------------------------------------

template <typename DELEGATE>
tdds::sub::Subscriber<DELEGATE>::~Subscriber()
{
    // implementation-defined
}


template <typename DELEGATE>
void tdds::sub::Subscriber<DELEGATE>::close()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE> template <typename T>
dds::sub::DataReader<T>
tdds::sub::Subscriber<DELEGATE>::create_datareader(
    const dds::topic::TopicDescription<T>& a_topic)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE> template <typename T>
dds::sub::DataReader<T>
tdds::sub::Subscriber<DELEGATE>::create_datareader(
    const dds::topic::TopicDescription<T>& a_topic,
    const dds::sub::DataReaderQos& qos,
    dds::sub::DataReaderListener<T>* lstn,
    const dds::core::StatusMask& lstn_mask)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template<typename DELEGATE>
const dds::sub::DataReaderQos
tdds::sub::Subscriber<DELEGATE>::get_default_datareader_qos() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::sub::Subscriber<DELEGATE>&
tdds::sub::Subscriber<DELEGATE>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- SubscriberQos: --------------------------------------------------------

template <typename DELEGATE>
tdds::sub::SubscriberQos<DELEGATE>::~SubscriberQos()
{
    // implementation-defined
}


template <typename DELEGATE>
dds::core::EntityQos::ConstQosPolicyMapType&
tdds::sub::SubscriberQos<DELEGATE>::policies() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
dds::core::EntityQos::QosPolicyMapType
tdds::sub::SubscriberQos<DELEGATE>::policies()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- Topic: ----------------------------------------------------------------

template <typename DELEGATE>
tdds::topic::TopicBase<DELEGATE>::TopicBase() : impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::topic::TopicBase<DELEGATE>::~TopicBase()
{
    // implementation-defined
}


template <typename DELEGATE>
tdds::topic::TopicBase<DELEGATE>::TopicBase(const TopicBase& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::topic::Topic<T>::Topic(const Topic& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::topic::Topic<T>::~Topic()
{
    // implementation-defined
}


template <typename DELEGATE>
void tdds::topic::TopicBase<DELEGATE>::close()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
const std::string
tdds::topic::TopicBase<DELEGATE>::get_name() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
dds::domain::DomainParticipant
tdds::topic::TopicBase<DELEGATE>::get_parent() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
const std::string
tdds::topic::TopicBase<DELEGATE>::get_type_name() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::topic::TopicBase<DELEGATE>&
tdds::topic::TopicBase<DELEGATE>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::topic::Topic<T>&
dds::topic::Topic<T>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- TopicDescription: -----------------------------------------------------

template <typename DELEGATE>
tdds::topic::TopicDescriptionBase<DELEGATE>::TopicDescriptionBase()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::topic::TopicDescriptionBase<DELEGATE>::TopicDescriptionBase(
    const TopicDescriptionBase& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::topic::TopicDescriptionBase<DELEGATE>::~TopicDescriptionBase()
{
    // implementation-defined
}


template <typename T>
dds::topic::TopicDescription<T>::TopicDescription()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::topic::TopicDescription<T>::TopicDescription(const TopicDescription& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::topic::TopicDescription<T>::~TopicDescription()
{
    // implementation-defined
}


template <typename DELEGATE>
void tdds::topic::TopicDescriptionBase<DELEGATE>::close()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
const std::string
tdds::topic::TopicDescriptionBase<DELEGATE>::get_name() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
dds::domain::DomainParticipant
tdds::topic::TopicDescriptionBase<DELEGATE>::get_parent() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
const std::string
tdds::topic::TopicDescriptionBase<DELEGATE>::get_type_name() const
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::topic::TopicDescriptionBase<DELEGATE>&
tdds::topic::TopicDescriptionBase<DELEGATE>::operator=(
    const TopicDescriptionBase& src)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::topic::TopicDescriptionBase<DELEGATE>&
tdds::topic::TopicDescriptionBase<DELEGATE>::operator=(
    const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T>
dds::topic::TopicDescription<T>&
dds::topic::TopicDescription<T>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


// --- TypeSupport: ----------------------------------------------------------

template <typename T, typename DELEGATE>
dds::type::TypeSupport<T, DELEGATE>::TypeSupport() : impl_()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename T, typename DELEGATE>
dds::type::TypeSupport<T, DELEGATE>::~TypeSupport()
{
    // implementation-defined
}


// --- WaitSet: --------------------------------------------------------------

template <typename DELEGATE>
tdds::core::WaitSet<DELEGATE>::~WaitSet()
{
    // implementation-defined
}


template <typename DELEGATE>
void tdds::core::WaitSet<DELEGATE>::attach_condition(
    const dds::core::Condition& cond)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::WaitSet<DELEGATE> tdds::core::WaitSet<DELEGATE>::create()
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
tdds::core::WaitSet<DELEGATE>&
tdds::core::WaitSet<DELEGATE>::operator=(const dds::core::null_type& n)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}


template <typename DELEGATE>
void tdds::core::WaitSet<DELEGATE>::wait(const dds::core::Duration& duration)
{
    // implementation-defined
    throw priv_dds::core::ImplUnsupportedError("unimplemented");
}




#endif // !defined(OMG_DDS_PRIV_DDS_POST_HPP_)
